home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 25 / CU Amiga Magazine's Super CD-ROM 25 (1998)(EMAP Images)(GB)(Track 1 of 2)[!][issue 1998-08].iso / CUCD / Programming / QuakeTools / src / libqtools / misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-11  |  8.1 KB  |  427 lines
  1. #define    LIBQTOOLS_CORE
  2. #include "../include/libqtools.h"
  3.  
  4. char *preProcessor = 0;
  5.  
  6. /*
  7.  * debug-tools
  8.  */
  9.  
  10. #ifdef    MEM_SIZETRACK
  11. #define    FRONTWALL    0
  12. #define    BACKWALL    0
  13.  
  14. #ifdef    MEM_ANALYSE
  15. int memcounter = 0;
  16. int mempeak = 0;
  17. int memallocs = 0;
  18. int mempeakallocs = 0;
  19. #endif
  20.  
  21. int tmalloc(register int size) {
  22.   int *ret;
  23.  
  24.   /* use calloc instead ? */
  25.   if ((ret = (int *)malloc(size + sizeof(int) + BACKWALL + FRONTWALL))) {
  26.     memset(ret + ((sizeof(int) + FRONTWALL)/sizeof(int)), 0, size);
  27.     
  28. #ifdef    MEM_ANALYSE
  29.     memcounter += size + sizeof(int) + BACKWALL + FRONTWALL;
  30.     memallocs++;
  31.     if(memcounter > mempeak)
  32.       mempeak = memcounter;
  33.     if(memallocs > mempeakallocs)
  34.       mempeakallocs = memallocs;
  35.     *ret++ = size;
  36. #endif
  37.     ret += (FRONTWALL/sizeof(int));
  38.   }
  39.   return (int)ret;
  40. }
  41.  
  42. void tfree(register void *adr) {
  43.   if (adr) {
  44. #if defined(__amigaos__) && defined(DEBUG)
  45.     int addr = (int)adr >> 28;
  46.     
  47.     if(addr) {
  48.       eprintf("leak found for %lx\n", adr);
  49.     }
  50.     else {    
  51.       int *ret = (int *)adr - (FRONTWALL/sizeof(int));
  52.  
  53. #ifdef    MEM_ANALYSE
  54.       memcounter -= *--ret - sizeof(int) - BACKWALL - FRONTWALL;
  55.       memallocs--;
  56. #endif
  57.       free(ret);
  58.     }
  59. #else
  60.     int *ret = (int *)adr - (FRONTWALL/sizeof(int));
  61.  
  62. #ifdef    MEM_ANALYSE
  63.     memcounter -= *--ret - sizeof(int) - BACKWALL - FRONTWALL;
  64.     memallocs--;
  65. #endif
  66.     free(ret);
  67. #endif
  68.   }
  69. }
  70.  
  71. int tsize(register void *adr) {
  72.   if (adr)
  73.     return *((int *)adr - (FRONTWALL/sizeof(int)) - sizeof(int));
  74.   else
  75.     return 0;
  76. }
  77.  
  78. int trealloc(register void *adr, register int newsize) {
  79.   if (adr) {
  80.     int *ret;
  81.     int oldsize = *((int *)adr - 1);
  82.     
  83.     if((ret = (int *)tmalloc(newsize))) {
  84.       /* copy only valid bytes, leave more bytes cleared */
  85.       memcpy(ret, adr, oldsize < newsize ? oldsize : newsize);
  86.     }
  87.     
  88.     tfree(adr);
  89.     return (int)ret;
  90.   }
  91.   else
  92.     return tmalloc(newsize);
  93. }
  94. #endif
  95.  
  96. /*
  97.  * an interface for temporary memtracking with automatic freeing after use
  98.  */
  99.  
  100. struct memtrack {
  101.   struct memtrack *next;
  102.   int something[0];
  103. };
  104.  
  105. struct memtrack *firstmalloc = 0;
  106. struct memtrack *lastmalloc = 0;
  107.  
  108. int kmalloc(register int size) {
  109.   struct memtrack *ret;
  110.   
  111.   if((ret = (struct memtrack *)tmalloc(size + sizeof(struct memtrack *)))) {
  112.     if(!firstmalloc) {
  113.       firstmalloc = ret;
  114.       lastmalloc = ret;
  115.     }
  116.     else {
  117.       lastmalloc->next = ret;
  118.       lastmalloc = ret;
  119.     }
  120.   }
  121.   return (int)&ret->something[0];
  122. }
  123.  
  124. void kfree(register void) {
  125.   if(firstmalloc) {
  126.     struct memtrack *first = firstmalloc;
  127.     struct memtrack *next;
  128.     
  129.     while(first) {
  130.       next = first->next;
  131.       tfree(first);
  132.       first = next;
  133.     }
  134.     
  135.     firstmalloc = 0;
  136.     lastmalloc = 0;
  137.   }
  138. }
  139.  
  140. char *smalloc(register char *in) {
  141.   char *string = 0;
  142.  
  143.   if(in)
  144.     if((string = (char *)tmalloc(strlen(in) + 1)))
  145.       strcpy(string, in);
  146.   return string;
  147. }
  148.  
  149. /*
  150.  * message handling
  151.  */
  152.  
  153. bool verbose = FALSE;
  154. bool fatal = FALSE;
  155. // longjump with this on error
  156. jmp_buf eabort;
  157.  
  158. void Error(char *error,...)
  159. {
  160.   va_list argptr;
  161.  
  162.   printf("Error: ");
  163.   va_start(argptr, error);
  164.   vprintf(error, argptr);
  165.   va_end(argptr);
  166.   fflush(stdout);
  167.   longjmp(eabort, 1);
  168. }
  169.  
  170. void eprintf(char *text, ...) {
  171.   va_list argptr;
  172.  
  173.   printf("Warning: ");
  174.   va_start(argptr, text);
  175.   vprintf(text, argptr);
  176.   va_end(argptr);
  177.   fflush(stdout);
  178.   if(fatal == TRUE)
  179.     longjmp(eabort, 1);
  180. }
  181.  
  182. #ifdef    VERBOSE
  183. void oprintf(char *text, ...) {
  184.   if(verbose == TRUE) {
  185.     va_list argptr;
  186.  
  187.     va_start(argptr, text);
  188.     vprintf(text, argptr);
  189.     va_end(argptr);
  190.     fflush(stdout);
  191.   }
  192. }
  193. #endif
  194.  
  195. void mprintf(char *text, ...) {
  196.   va_list argptr;
  197.  
  198.   va_start(argptr, text);
  199.   vprintf(text, argptr);
  200.   va_end(argptr);
  201.   fflush(stdout);
  202. }
  203.  
  204. /*
  205.  * platform-independent progressbar (text-based)
  206.  */
  207.  
  208. void mprogress(register int max, register int current) {
  209. #ifdef VALID_ESCAPES
  210.   printf("\n\eM    - %2.2f%%", (float)(current * 100) / max);
  211.   if(current >= max)
  212.     printf("\n\eM");
  213.   fflush(stdout);
  214. #else
  215.   printf("\xD\x9B\x4B    - %2.2f%%", (float)(current * 100) / max);
  216.   if(current >= max)
  217.     printf("\xD\x9B\x4B");
  218.   fflush(stdout);
  219. #endif
  220. }
  221.  
  222. /*
  223.  * disk-tools
  224.  */
  225.  
  226. void CreatePath(register char *fileName) {
  227.   char *delAdr1 = fileName, *delAdr2 = fileName;
  228.  
  229.   while ((delAdr2 = (char *)index(delAdr1, '/'))) {
  230.     *delAdr2 = '\0';
  231.     mkdir(fileName, 0x0777);
  232.     *delAdr2 = '/';
  233.     delAdr1 = ++delAdr2;
  234.   }
  235. }
  236.  
  237. char *GetExt(register char *Name) {
  238.   if(Name) {
  239.     char *Ext = (char *)rindex(Name, '.');
  240.  
  241.     if (!Ext)
  242.       return (char *)index(Name, '\0');
  243.     else {
  244.       /*
  245.        * delete everything after 4 chars 
  246.        * Ext[4] = '\0';
  247.        */
  248.       return ++Ext;
  249.     }
  250.   }
  251.   else
  252.     return 0;
  253. }
  254.  
  255. void StripExt(register char *Name) {
  256.   if(Name) {
  257.     char *Ext;
  258.  
  259.     if ((Ext = (char *)rindex(Name, '.')))
  260.       *Ext = '\0';
  261.   }
  262. }
  263.  
  264. void ReplaceExt(register char *Name, register char *newExt) {
  265.   if(Name) {
  266.     char *Ext;
  267.  
  268.     if ((Ext = (char *)rindex(Name, '.'))) {
  269.       *++Ext = '\0';
  270.       strcpy(Ext, newExt);
  271.     }
  272.     else {
  273.       strcat(Name, ".");
  274.       strcat(Name, newExt);
  275.     }
  276.   }
  277. }
  278.  
  279. /*
  280.  * get the file-part of a path
  281.  */
  282. char *GetFile(register char *Name) {
  283.   if(Name) {
  284.     char *Ext = (char *)rindex(Name, '/');
  285.  
  286.     if (!Ext)
  287.       return Name;
  288.     else {
  289.       return ++Ext;
  290.     }
  291.   }
  292.   else
  293.     return 0;
  294. }
  295.  
  296. /*
  297.  * check for valid unix-path
  298.  */
  299. void ValidateDir(register char *Name) {
  300.   short int len = strlen(Name);
  301.   while(Name[len] == '/')
  302.     Name[len--] = '\0';
  303. }
  304.  
  305. void *GetVoidF(register FILE *getFile) {
  306.   void *voidData = 0;
  307.   int size;
  308.  
  309.   fseek(getFile, 0, SEEK_END);
  310.   size = ftell(getFile);
  311.   fseek(getFile, 0, SEEK_SET);
  312.  
  313.   if ((voidData = (void *)tmalloc(size + 1))) {
  314.     char *byteData = (char *)voidData;
  315.     
  316.     fread(voidData, 1, size, getFile);
  317.     byteData[size] = '\0';
  318.   }
  319.   else
  320.     eprintf("cannot tmalloc %d bytes memory for voiddata\n", size);
  321.   
  322.   return voidData;
  323. }
  324.  
  325. void *GetVoid(register char *fileName) {
  326.   FILE *getFile = fopen(fileName, READ_BINARY);
  327.   void *voidData = 0;
  328.   
  329.   if(getFile) {
  330.     voidData = GetVoidF(getFile);
  331.     fclose(getFile);
  332.   }
  333.  
  334.   return voidData;
  335. }
  336.  
  337. void *GetPreProcessed(register char *fileName) {
  338.   if(preProcessor) {
  339.     char *tmpName;
  340.     void *tmpData = 0;
  341.     
  342.     if((tmpName = tmpnam(0))) {
  343.       char *exeLine;
  344.       
  345.       if((exeLine = (char *)tmalloc(strlen(preProcessor) + 1 + strlen(fileName) + 1 + strlen(tmpName) + 1))) {
  346.         strcpy(exeLine, preProcessor);
  347.         strcat(exeLine, " ");
  348.         strcat(exeLine, fileName);
  349.         strcat(exeLine, " ");
  350.         strcat(exeLine, tmpName);
  351.         
  352.         system(exeLine);
  353.         
  354.         tmpData = GetVoid(tmpName);
  355.         remove(tmpName);
  356.       }
  357.     }
  358.     
  359.     return tmpData;
  360.   }
  361.   else
  362.     return GetVoid(fileName);
  363. }
  364.  
  365. /*
  366.  * cuts bytes out of a file
  367.  * (file is REAL shorter)
  368.  * stores cuttet bytes if buffer != 0
  369.  */
  370. bool CutOff(FILE *procFile, int byteValue, void *buffer) {
  371.   int begin = ftell(procFile);
  372.   int difference;
  373.  
  374.   if(buffer) {
  375.     if(fread(buffer, 1, byteValue, procFile) != byteValue)
  376.       return FALSE;
  377.   }
  378.   /*
  379.    * cut of in steps
  380.    */
  381.   fseek(procFile, 0, SEEK_END);
  382.   difference = ftell(procFile) - begin;
  383.   if((buffer = (void *)tmalloc(difference))) {
  384.     fseek(procFile, begin + byteValue, SEEK_SET);
  385.     fread(buffer, 1, difference, procFile);
  386.     fseek(procFile, begin, SEEK_SET);
  387.     fwrite(buffer, 1, difference, procFile);
  388.     //fsetsize(begin + difference - byteValue);
  389.     fseek(procFile, begin, SEEK_SET);
  390.     return TRUE;
  391.   }
  392.   else
  393.     return FALSE;
  394. }
  395.  
  396. /*
  397.  * pastes bytes to a file
  398.  * (file is REAL longer)
  399.  * write bytes if buffer != 0
  400.  */
  401. bool PasteIn(FILE *procFile, int byteValue, void *buffer) {
  402.   int begin = ftell(procFile);
  403.   int difference;
  404.   void *bufferNew;
  405.   
  406.   if(!buffer)
  407.     buffer = (void *)memcounter;    /* copy something */
  408.   
  409.   /*
  410.    * paste in in steps
  411.    */
  412.   fseek(procFile, 0, SEEK_END);
  413.   difference = ftell(procFile) - begin;
  414.   if((bufferNew = (void *)tmalloc(difference)) && buffer) {
  415.     fseek(procFile, begin, SEEK_SET);
  416.     fread(bufferNew, 1, difference, procFile);
  417.     fseek(procFile, begin, SEEK_SET);
  418.     fwrite(buffer, 1, byteValue, procFile);
  419.     fwrite(bufferNew, 1, difference, procFile);
  420.     fseek(procFile, begin, SEEK_SET);
  421.     tfree(bufferNew);
  422.     return TRUE;
  423.   }
  424.   else
  425.     return FALSE;
  426. }
  427.